home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / UsingPDF / GhostScript / source / gs5.10 / ilocate.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-09-04  |  11.3 KB  |  406 lines
  1. /* Copyright (C) 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* ilocate.c */
  20. /* Object locating and validating for Ghostscript memory manager */
  21. #include "ghost.h"
  22. #include "memory_.h"
  23. #include "errors.h"
  24. #include "gsexit.h"
  25. #include "gsstruct.h"
  26. #include "iastate.h"
  27. #include "idict.h"
  28. #include "igc.h"            /* for gc_state_t */
  29. #include "igcstr.h"            /* for prototype */
  30. #include "iname.h"
  31. #include "ipacked.h"
  32. #include "isstate.h"
  33. #include "iutil.h"            /* for packed_get */
  34. #include "ivmspace.h"
  35. #include "store.h"
  36.  
  37. /* ================ Locating ================ */
  38.  
  39. /* Locate a pointer in the chunks of a space being collected. */
  40. /* This is only used for string garbage collection and for debugging. */
  41. chunk_t *
  42. gc_locate(const void *ptr, gc_state_t *gcst)
  43. {    const gs_ref_memory_t *mem;
  44.     if ( chunk_locate(ptr, &gcst->loc) )
  45.       return gcst->loc.cp;
  46.     mem = gcst->loc.memory;
  47.     /* Try the other space, if there is one. */
  48.     if ( gcst->space_local != gcst->space_global )
  49.       { gcst->loc.memory =
  50.           (mem->space == avm_local ? gcst->space_global : gcst->space_local);
  51.         gcst->loc.cp = 0;
  52.         if ( chunk_locate(ptr, &gcst->loc) )
  53.           return gcst->loc.cp;
  54.         /* Try other save levels of this space. */
  55.         while ( gcst->loc.memory->saved != 0 )
  56.           { gcst->loc.memory = &gcst->loc.memory->saved->state;
  57.         gcst->loc.cp = 0;
  58.         if ( chunk_locate(ptr, &gcst->loc) )
  59.           return gcst->loc.cp;
  60.           }
  61.       }
  62.     /* Try the system space.  This is simpler because it isn't */
  63.     /* subject to save/restore. */
  64.     if ( mem != gcst->space_system )
  65.     {    gcst->loc.memory = gcst->space_system;
  66.         gcst->loc.cp = 0;
  67.         if ( chunk_locate(ptr, &gcst->loc) )
  68.           return gcst->loc.cp;
  69.     }
  70.     /* Try other save levels of the initial space, */
  71.     /* or of global space if the original space was system space. */
  72.     /* In the latter case, try all levels. */
  73.     gcst->loc.memory =
  74.       (mem == gcst->space_system || mem->space == avm_global ?
  75.        gcst->space_global : gcst->space_local);
  76.     for ( ; ; )
  77.       { if ( gcst->loc.memory != mem )    /* don't do twice */
  78.           { gcst->loc.cp = 0;
  79.         if ( chunk_locate(ptr, &gcst->loc) )
  80.           return gcst->loc.cp;
  81.           }
  82.         if ( gcst->loc.memory->saved == 0 )
  83.           break;
  84.         gcst->loc.memory = &gcst->loc.memory->saved->state;
  85.       }
  86.     /* Restore locator to a legal state. */
  87.     gcst->loc.memory = mem;
  88.     gcst->loc.cp = 0;
  89.     return 0;
  90. }
  91.  
  92. /* ================ Debugging ================ */
  93.  
  94. #ifdef DEBUG
  95.  
  96. /* Validate the contents of an allocator. */
  97. void
  98. ialloc_validate_spaces(const gs_dual_memory_t *dmem)
  99. {    int i;
  100.     gc_state_t state;
  101. #define nspaces countof(dmem->spaces.indexed)
  102.     chunk_t cc[nspaces];
  103.     uint rsize[nspaces];
  104.     ref rlast[nspaces];
  105.  
  106.     state.spaces = dmem->spaces;
  107.     state.loc.memory = state.spaces.named.local;
  108.     state.loc.cp = 0;
  109.  
  110.     /* Save everything we need to reset temporarily. */
  111.     for ( i = 0; i < nspaces; i++ )
  112.       if ( dmem->spaces.indexed[i] != 0 )
  113.         {    gs_ref_memory_t *mem = dmem->spaces.indexed[i];
  114.         chunk_t *pcc = mem->pcc;
  115.         obj_header_t *rcur = mem->cc.rcur;
  116.         if ( pcc != 0 )
  117.           {    cc[i] = *pcc;
  118.             *pcc = mem->cc;
  119.           }
  120.         if ( rcur != 0 )
  121.           {    rsize[i] = rcur[-1].o_size;
  122.             rcur[-1].o_size = mem->cc.rtop - (byte *)rcur;
  123.             /* Create the final ref, reserved for the GC. */
  124.             rlast[i] = ((ref *)mem->cc.rtop)[-1];
  125.             make_mark((ref *)mem->cc.rtop - 1);
  126.           }
  127.         }
  128.  
  129.     /* Validate memory. */
  130.     for ( i = 0; i < nspaces; i++ )
  131.       if ( dmem->spaces.indexed[i] != 0 )
  132.         ialloc_validate_memory(dmem->spaces.indexed[i], &state);
  133.  
  134.     /* Undo temporary changes. */
  135.     for ( i = 0; i < nspaces; i++ )
  136.       if ( dmem->spaces.indexed[i] != 0 )
  137.         {    gs_ref_memory_t *mem = dmem->spaces.indexed[i];
  138.         chunk_t *pcc = mem->pcc;
  139.         obj_header_t *rcur = mem->cc.rcur;
  140.         if ( rcur != 0 )
  141.           {    rcur[-1].o_size = rsize[i];
  142.             ((ref *)mem->cc.rtop)[-1] = rlast[i];
  143.           }
  144.         if ( pcc != 0 )
  145.           *pcc = cc[i];
  146.         }
  147. }
  148. void
  149. ialloc_validate_memory(const gs_ref_memory_t *mem, gc_state_t *gcst)
  150. {    const gs_ref_memory_t *smem;
  151.     int level;
  152.  
  153.     for ( smem = mem, level = 0; smem != 0;
  154.           smem = &smem->saved->state, --level
  155.         )
  156.       { const chunk_t *cp;
  157.         int i;
  158.  
  159.         if_debug3('6', "[6]validating memory 0x%lx, space %d, level %d\n",
  160.               (ulong)mem, mem->space, level);
  161.         /* Validate chunks. */
  162.         for ( cp = smem->cfirst; cp != 0; cp = cp->cnext )
  163.           ialloc_validate_chunk(cp, gcst);
  164.         /* Validate freelists. */
  165.         for ( i = 0; i < num_freelists; ++i )
  166.           { uint free_size = i << log2_obj_align_mod;
  167.         const obj_header_t *pfree;
  168.  
  169.         for ( pfree = mem->freelists[i]; pfree != 0;
  170.               pfree = *(const obj_header_t * const *)pfree
  171.             )
  172.           { uint size = pfree[-1].o_size;
  173.  
  174.             if ( pfree[-1].o_type != &st_free )
  175.               { lprintf3("Non-free object 0x%lx(%u) on freelist %i!\n",
  176.                  (ulong)pfree, size, i);
  177.                 break;
  178.               }
  179.             if ( size < free_size - obj_align_mask ||
  180.              size > free_size 
  181.                )
  182.               { lprintf3("Object 0x%lx(%u) size wrong on freelist %i!\n",
  183.                  (ulong)pfree, size, i);
  184.                 break;
  185.               }
  186.           }
  187.           }
  188.       };
  189. }
  190.  
  191. /* Check the validity of an object's size. */
  192. #define object_size_valid(pre, size, cp)\
  193. ((pre)->o_large ? (const byte *)(pre) == (cp)->cbase :\
  194.   (size) <= (cp)->ctop - (const byte *)((pre) + 1))
  195.  
  196. /* Validate all the objects in a chunk. */
  197. private void ialloc_validate_ref(P2(const ref *, gc_state_t *));
  198. void
  199. ialloc_validate_chunk(const chunk_t *cp, gc_state_t *gcst)
  200. {    if_debug_chunk('6', "[6]validating chunk", cp);
  201.     SCAN_CHUNK_OBJECTS(cp);
  202.       DO_ALL
  203.         if ( pre->o_type == &st_free )
  204.           { if ( !object_size_valid(pre, size, cp) )
  205.               lprintf3("Bad free object 0x%lx(%lu), in chunk 0x%lx!\n",
  206.                    (ulong)(pre + 1), (ulong)size, (ulong)cp);
  207.           }
  208.         else
  209.           ialloc_validate_object(pre + 1, cp, gcst);
  210.         if_debug3('7', " [7]validating %s(%lu) 0x%lx\n",
  211.               struct_type_name_string(pre->o_type),
  212.               (ulong)size, (ulong)pre);
  213.         if ( pre->o_type == &st_refs )
  214.           {    const ref_packed *rp = (const ref_packed *)(pre + 1);
  215.             const char *end = (const char *)rp + size;
  216.  
  217.             while ( (const char *)rp < end )
  218.               if ( r_is_packed(rp) )
  219.                 { ref unpacked;
  220.                   packed_get(rp, &unpacked);
  221.                   ialloc_validate_ref(&unpacked, gcst);
  222.                   rp++;
  223.                 }
  224.               else
  225.                 { ialloc_validate_ref((const ref *)rp, gcst);
  226.                   rp += packed_per_ref;
  227.                 }
  228.           }
  229.         else
  230.           {    struct_proc_enum_ptrs((*proc)) =
  231.               pre->o_type->enum_ptrs;
  232.             uint index = 0;
  233.             const void *ptr;
  234.             gs_ptr_type_t ptype;
  235.  
  236.             if ( proc != 0 )
  237.               for ( ; (ptype = (*proc)(pre + 1, size, index, &ptr)) != 0; ++index )
  238.                 if ( ptr == 0 )
  239.                   DO_NOTHING;
  240.                 else if ( ptype == ptr_struct_type )
  241.                   ialloc_validate_object(ptr, NULL, gcst);
  242.                 else if ( ptype == ptr_ref_type )
  243.                   ialloc_validate_ref(ptr, gcst);
  244.           }
  245.     END_OBJECTS_SCAN
  246. }
  247. /* Validate a ref. */
  248. private void
  249. ialloc_validate_ref(const ref *pref, gc_state_t *gcst)
  250. {    const void *optr;
  251.     const ref *rptr;
  252.     const char *tname;
  253.     uint size;
  254.  
  255.     if ( !gs_debug_c('?') )
  256.       return;            /* no check */
  257.     if ( r_space(pref) == avm_foreign )
  258.       return;
  259.     switch ( r_type(pref) )
  260.       {
  261.       case t_file:
  262.         optr = pref->value.pfile;
  263.         goto cks;
  264.       case t_device:
  265.         optr = pref->value.pdevice;
  266.         goto cks;
  267.       case t_fontID:
  268.       case t_struct:
  269.       case t_astruct:
  270.         optr = pref->value.pstruct;
  271. cks:        if ( optr != 0 )
  272.           ialloc_validate_object(optr, NULL, gcst);
  273.         break;
  274.       case t_name:
  275.         if ( name_index_ptr(r_size(pref)) != pref->value.pname )
  276.           {    lprintf3("At 0x%lx, bad name %u, pname = 0x%lx\n",
  277.                  (ulong)pref, (uint)r_size(pref),
  278.                  (ulong)pref->value.pname);
  279.             break;
  280.           }
  281.         {    ref sref;
  282.             name_string_ref(pref, &sref);
  283.             if ( r_space(&sref) != avm_foreign &&
  284.                  !gc_locate(sref.value.const_bytes, gcst)
  285.                )
  286.               {    lprintf4("At 0x%lx, bad name %u, pname = 0x%lx, string 0x%lx not in any chunk\n",
  287.                      (ulong)pref, (uint)r_size(pref),
  288.                      (ulong)pref->value.pname,
  289.                      (ulong)sref.value.const_bytes);
  290.               }
  291.         }
  292.         break;
  293.       case t_string:
  294.         if ( r_size(pref) != 0 && !gc_locate(pref->value.bytes, gcst) )
  295.           lprintf3("At 0x%lx, string ptr 0x%lx[%u] not in any chunk\n",
  296.                (ulong)pref, (ulong)pref->value.bytes,
  297.                (uint)r_size(pref));
  298.         break;
  299.       case t_array:
  300.         if ( r_size(pref) == 0 )
  301.           break;
  302.         rptr = pref->value.refs;
  303.         size = r_size(pref);
  304.         tname = "array";
  305. cka:        if ( !gc_locate(rptr, gcst) )
  306.           { lprintf3("At 0x%lx, %s 0x%lx not in any chunk\n",
  307.                  (ulong)pref, tname, (ulong)rptr);
  308.             break;
  309.           }
  310.         { uint i;
  311.           for ( i = 0; i < size; ++i )
  312.             { const ref *elt = rptr + i;
  313.               if ( r_is_packed(elt) )
  314.             lprintf5("At 0x%lx, %s 0x%lx[%u] element %u is not a ref\n",
  315.                  (ulong)pref, tname, (ulong)rptr, size, i);
  316.             }
  317.         }
  318.         break;
  319.       case t_shortarray:
  320.       case t_mixedarray:
  321.         if ( r_size(pref) == 0 )
  322.           break;
  323.         optr = pref->value.packed;
  324.         if ( !gc_locate(optr, gcst) )
  325.           lprintf2("At 0x%lx, packed array 0x%lx not in any chunk\n",
  326.                (ulong)pref, (ulong)optr);
  327.         break;
  328.       case t_dictionary:
  329.         { const dict *pdict = pref->value.pdict;
  330.           if ( !r_has_type(&pdict->values, t_array) ||
  331.                !r_is_array(&pdict->keys) ||
  332.                !r_has_type(&pdict->count, t_integer) ||
  333.                !r_has_type(&pdict->maxlength, t_integer)
  334.              )
  335.             lprintf2("At 0x%lx, invalid dict 0x%lx\n",
  336.                  (ulong)pref, (ulong)pdict);
  337.           rptr = (const ref *)pdict;
  338.         }
  339.         size = sizeof(dict) / sizeof(ref);
  340.         tname = "dict";
  341.         goto cka;
  342.       }
  343. }
  344.  
  345. /* Validate an object. */
  346. void
  347. ialloc_validate_object(const obj_header_t *ptr, const chunk_t *cp,
  348.   gc_state_t *gcst)
  349. {    const obj_header_t *pre = ptr - 1;
  350.     ulong size = pre_obj_contents_size(pre);
  351.     gs_memory_type_ptr_t otype = pre->o_type;
  352.     const char *oname;
  353.  
  354.     if ( !gs_debug_c('?') )
  355.       return;            /* no check */
  356.     if ( cp == 0 && gcst != 0 )
  357.     {    gc_state_t st;
  358.         st = *gcst;        /* no side effects! */
  359.         if ( !(cp = gc_locate(pre, &st)) )
  360.         {    lprintf1("Object 0x%lx not in any chunk!\n",
  361.                  (ulong)ptr);
  362.             return;/*gs_abort();*/
  363.         }
  364.     }
  365.     if ( otype == &st_free )
  366.       { lprintf3("Reference to free object 0x%lx(%lu), in chunk 0x%lx!\n",
  367.              (ulong)ptr, (ulong)size, (ulong)cp);
  368.         gs_abort();
  369.       }
  370.     if ( (cp != 0 && !object_size_valid(pre, size, cp)) ||
  371.          otype->ssize == 0 ||
  372.          size % otype->ssize != 0 ||
  373.          (oname = struct_type_name_string(otype),
  374.           *oname < 33 || *oname > 126)
  375.        )
  376.     {    lprintf4("Bad object 0x%lx(%lu), ssize = %u, in chunk 0x%lx!\n",
  377.              (ulong)ptr, (ulong)size, otype->ssize, (ulong)cp);
  378.         gs_abort();
  379.     }
  380. }
  381.  
  382. #else                /* !DEBUG */
  383.  
  384. void
  385. ialloc_validate_spaces(const gs_dual_memory_t *dmem)
  386. {
  387. }
  388.  
  389. void
  390. ialloc_validate_memory(const gs_ref_memory_t *mem, gc_state_t *gcst)
  391. {
  392. }
  393.  
  394. void
  395. ialloc_validate_chunk(const chunk_t *cp, gc_state_t *gcst)
  396. {
  397. }
  398.  
  399. void
  400. ialloc_validate_object(const obj_header_t *ptr, const chunk_t *cp,
  401.   gc_state_t *gcst)
  402. {
  403. }
  404.  
  405. #endif                /* (!)DEBUG */
  406.